package com.jingyi.common.utils;

import java.util.*;

/**
 * 字符串工具类
 * 
 * @author linzhihai
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
    /** 空字符串 */
    private static final String NULL_STR = "";

    /** 下划线 */
    private static final char SEPARATOR = '_';

    /**
     * 获取参数不为空值
     * 
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue)
    {
        return value != null ? value : defaultValue;
    }

    /**
     * * 判断一个Collection是否为空，包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll)
    {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个Collection是否非空，包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll)
    {
        return !isEmpty(coll);
    }

    /**
     * * 判断一个对象数组是否为空
     * 
     * @param objects 要判断的对象数组
     ** @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects)
    {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个对象数组是否非空
     * 
     * @param objects 要判断的对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects)
    {
        return !isEmpty(objects);
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map)
    {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map)
    {
        return !isEmpty(map);
    }

    /**
     * * 判断一个字符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str)
    {
        return isNull(str) || NULL_STR.equals(str.trim());
    }

    /**
     * * 判断一个字符串是否为非空串
     * 
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }

    /**
     * 去空格
     */
    public static String trim(String str)
    {
        return (str == null ? "" : str.trim());
    }

    /**
     * 返回指定对象的String值，如果无法解析成String，返回空字符串
     *
     * @param object
     * @return str
     */
    public static String asString(Object object)
    {
        return asString(object, "");
    }

    /**
     * 返回指定对象的String值，如果对象为null返回默认值，否则返回对象的toString()方法
     *
     * @param object
     * @param defaultValue
     * @return str
     */
    public static String asString(Object object, String defaultValue)
    {
        if (isNull(object))
        {
            return defaultValue;
        }

        if (object instanceof String)
        {
            return (String) object;
        }
        else
        {
            return object.toString();
        }
    }

    /**
     * 返回指定对象的int值，如果无法解析成int，返回0
     *
     * @param object
     * @return int
     */
    public static int asInt(Object object)
    {
        return asInt(object, 0);
    }

    /**
     * 返回指定对象的int值，如果对象为null返回默认值
     *
     * @param object
     * @param defaultValue
     * @return int
     */
    public static int asInt(Object object, int defaultValue)
    {
        if (isNull(object))
        {
            return defaultValue;
        }

        int value = defaultValue;
        if (object instanceof String)
        {
            String str = (String) object;
            if (StringUtils.isNotBlank(str))
            {
                try
                {
                    value = Integer.parseInt(str);
                }
                catch (NumberFormatException e)
                {
                    e.printStackTrace();
                }
            }
        }
        else if (object instanceof Number)
        {
            value = ((Number) object).intValue();
        }
        return value;
    }

    /**
     * 返回指定对象的long值，如果无法解析成long，返回0L
     *
     * @param object
     * @return str
     */
    public static long asLong(Object object)
    {
        return asLong(object, 0L);
    }

    /**
     * 返回指定对象的String值，如果对象为null返回默认值，否则返回对象的toString()方法
     *
     * @param object
     * @param defaultValue
     * @return long
     */
    public static long asLong(Object object, Long defaultValue)
    {
        if (isNull(object))
        {
            return defaultValue;
        }

        long value = defaultValue;
        if (object instanceof String)
        {
            String str = (String) object;
            if (StringUtils.isNotBlank(str))
            {
                try
                {
                    value = Long.parseLong(str);
                }
                catch (NumberFormatException e)
                {
                    e.printStackTrace();
                }
            }
        }
        else if (object instanceof Number)
        {
            value = ((Number) object).longValue();
        }
        return value;
    }
}